<!--
结构伪类选择器
    - 伪类选择器中的一种
    - 根据文档结构来选择标签，故称为结构伪类选择器
    - 常用于父容器中选取子元素
    
    :first-child        第一个
    :last-child         最后一个
    :first-of-type      指定类型的第一个
    :last-of-type       指定类型的最后一个
    
    :nth-child(n)       前往后，第n个
    :nth-last-child(n)  后往前，第n个
    :nth-of-type(n)     指定类型的第n个

用法
    父 :伪类选择器      // 不推荐
    ul :first-child    // 权重：1+10

    父 子:伪类选择器    // 推荐
    ul li:first-child  // 权重：1+1+10

关于nth-child(n)的n的取值
    数字
        第几个，标签索引位置从1开始
    关键字
        odd，奇数
        even，偶数
    公式
        1）“公式中的数字n”
            从0开始，每次自增1，即：0、1、2、3、4...
        2）“标签索引位置”
            从1开始，即：1、2、3、4...那些非法索引会被忽略（负数、0、越界索引都是无效索引，会被忽略）
        3）结束计算的条件
            越界时便会停止公式的计算
            “界”指的是上下界（注意：不一定指边界）
                下边界---------【第n个---------上边界】
                    上界 = 上边界（最后一个）
                        或者
                    上界 = 指定位置（第几个那里）

                【下边界---------第n个】---------上边界
                    下界 = 下边界（第一个）
                        或者
                    下界 = 指定位置（第几个那里）
        4）公式中的字母必须是“n”或“N”，使用其它字母是无效的
        5）只要结果是有效索引范围内的，公式怎么写都行
        注意：若有【-n】【-2n】等负号的情况时，【-n】【-2n】等必须写在公式最前面，否则无效
            有效：【-n+3】
            无效：【3-n】、【3+(-n)】
        -------------- 下界 --》上界
        【n】
            公式结果：0、1、2、3、4...
            最终索引：0无效，最后是【1、2、3、4...】
            大于0的自然数，直至最后一个
        【2n】
            公式结果：0、2、4、6...
            最终索引：0无效，最后是【2、4、6...】
            偶数，直至最后一个
        【2n+1】
            公式结果：1、3、5、7...
            最终索引：【1、3、5、7...】
            奇数，直至最后一个
        【2n-1】
            公式结果：-1、1、3、5、7...
            最终索引：-1无效，最后是【1、3、5、7...】
            奇数，直至最后一个
        【5n】
            公式结果：0、5、10、15...
            最终索引：0无效，最后是【5、10、15...】
            5的倍数，直至最后一个
        【n+3】
            公式结果：3、4、5、6、7...
            最终索引：【3、4、5、6、7...】
            从第3个开始，每次递增1，直至最后一个
        【2n+3】
            公式结果：3、5、7、9、11...
            最终索引：【3、5、7、9、11...】
            从第3个开始，每次递增2，直至最后一个

        -------------- 上界 --》下界
        【-n+3】
            公式结果：3、2、1、0，计算到0后不再计算
            最终索引：0无效，最后是【3、2、1】
            从第3个开始，每次递减1，直至第一个
        【-2n+10】
            公式结果：10、8、6、4、2、0，计算到0后不再计算
            最终结果：0无效，最后是【10、8、6、4、2】
            从第10个开始，每次递减2，直至下界（不一定指第一个）
            
        --------------
-->
<style>
  /* ul li:first-child {
    color: red;
  } */

  /* ul li:nth-child(3) {
    background-color: cyan;
  } */
  /* ul li:nth-child(even) {
    border-left: 5px double blue;
  } */
  ul li:nth-child(-3n + 7) {
    background-color: cyan;
  }
</style>
<ul>
  <li>第1个li标签</li>
  <li>第2个li标签</li>
  <li>第3个li标签</li>
  <li>第4个li标签</li>
  <li>第5个li标签</li>
  <li>第6个li标签</li>
  <li>第7个li标签</li>
  <li>第8个li标签</li>
  <li>第9个li标签</li>
  <li>第10个li标签</li>
  <li>第11个li标签</li>
  <li>第12个li标签</li>
</ul>
